home *** CD-ROM | disk | FTP | other *** search
/ PC Advisor 2010 April / PCA177.iso / ESSENTIALS / Firefox Setup.exe / nonlocalized / chrome / browser.jar / content / browser / sanitize.js < prev    next >
Encoding:
JavaScript  |  2009-07-15  |  14.8 KB  |  447 lines
  1. //@line 41 "e:\builds\moz2_slave\win32_build\build\browser\base\content\sanitize.js"
  2.  
  3. function Sanitizer() {}
  4. Sanitizer.prototype = {
  5.   // warning to the caller: this one may raise an exception (e.g. bug #265028)
  6.   clearItem: function (aItemName)
  7.   {
  8.     if (this.items[aItemName].canClear)
  9.       this.items[aItemName].clear();
  10.   },
  11.  
  12.   canClearItem: function (aItemName)
  13.   {
  14.     return this.items[aItemName].canClear;
  15.   },
  16.   
  17.   prefDomain: "",
  18.   
  19.   getNameFromPreference: function (aPreferenceName)
  20.   {
  21.     return aPreferenceName.substr(this.prefDomain.length);
  22.   },
  23.   
  24.   /**
  25.    * Deletes privacy sensitive data in a batch, according to user preferences
  26.    *
  27.    * @returns  null if everything's fine;  an object in the form
  28.    *           { itemName: error, ... } on (partial) failure
  29.    */
  30.   sanitize: function ()
  31.   {
  32.     var psvc = Components.classes["@mozilla.org/preferences-service;1"]
  33.                          .getService(Components.interfaces.nsIPrefService);
  34.     var branch = psvc.getBranch(this.prefDomain);
  35.     var errors = null;
  36.  
  37.     // Cache the range of times to clear
  38.     if (this.ignoreTimespan)
  39.       var range = null;  // If we ignore timespan, clear everything
  40.     else
  41.       range = this.range || Sanitizer.getClearRange();
  42.       
  43.     for (var itemName in this.items) {
  44.       var item = this.items[itemName];
  45.       item.range = range;
  46.       if ("clear" in item && item.canClear && branch.getBoolPref(itemName)) {
  47.         // Some of these clear() may raise exceptions (see bug #265028)
  48.         // to sanitize as much as possible, we catch and store them, 
  49.         // rather than fail fast.
  50.         // Callers should check returned errors and give user feedback
  51.         // about items that could not be sanitized
  52.         try {
  53.           item.clear();
  54.         } catch(er) {
  55.           if (!errors) 
  56.             errors = {};
  57.           errors[itemName] = er;
  58.           dump("Error sanitizing " + itemName + ": " + er + "\n");
  59.         }
  60.       }
  61.     }
  62.     return errors;
  63.   },
  64.   
  65.   // Time span only makes sense in certain cases.  Consumers who want
  66.   // to only clear some private data can opt in by setting this to false,
  67.   // and can optionally specify a specific range.  If timespan is not ignored,
  68.   // and range is not set, sanitize() will use the value of the timespan
  69.   // pref to determine a range
  70.   ignoreTimespan : true,
  71.   range : null,
  72.   
  73.   items: {
  74.     cache: {
  75.       clear: function ()
  76.       {
  77.         const Cc = Components.classes;
  78.         const Ci = Components.interfaces;
  79.         var cacheService = Cc["@mozilla.org/network/cache-service;1"].
  80.                           getService(Ci.nsICacheService);
  81.         try {
  82.           // Cache doesn't consult timespan, nor does it have the
  83.           // facility for timespan-based eviction.  Wipe it.
  84.           cacheService.evictEntries(Ci.nsICache.STORE_ANYWHERE);
  85.         } catch(er) {}
  86.       },
  87.       
  88.       get canClear()
  89.       {
  90.         return true;
  91.       }
  92.     },
  93.     
  94.     cookies: {
  95.       clear: function ()
  96.       {
  97.         const Ci = Components.interfaces;
  98.         var cookieMgr = Components.classes["@mozilla.org/cookiemanager;1"]
  99.                                   .getService(Ci.nsICookieManager);
  100.         if (this.range) {
  101.           // Iterate through the cookies and delete any created after our cutoff.
  102.           var cookiesEnum = cookieMgr.enumerator;
  103.           while (cookiesEnum.hasMoreElements()) {
  104.             var cookie = cookiesEnum.getNext().QueryInterface(Ci.nsICookie2);
  105.             
  106.             if (cookie.creationTime > this.range[0])
  107.               // This cookie was created after our cutoff, clear it
  108.               cookieMgr.remove(cookie.host, cookie.name, cookie.path, false);
  109.           }
  110.         }
  111.         else {
  112.           // Remove everything
  113.           cookieMgr.removeAll();
  114.         }
  115.  
  116.         // clear any network geolocation provider sessions
  117.         var psvc = Components.classes["@mozilla.org/preferences-service;1"]
  118.                              .getService(Components.interfaces.nsIPrefService);
  119.         try {
  120.             var branch = psvc.getBranch("geo.wifi.access_token.");
  121.             branch.deleteBranch("");
  122.         } catch (e) {}
  123.  
  124.       },
  125.       
  126.       get canClear()
  127.       {
  128.         return true;
  129.       }
  130.     },
  131.     
  132.     offlineApps: {
  133.       clear: function ()
  134.       {
  135.         const Cc = Components.classes;
  136.         const Ci = Components.interfaces;
  137.         var cacheService = Cc["@mozilla.org/network/cache-service;1"].
  138.                            getService(Ci.nsICacheService);
  139.         try {
  140.           // Offline app data is "timeless", and doesn't respect
  141.           // the setting of timespan, it always clears everything
  142.           cacheService.evictEntries(Ci.nsICache.STORE_OFFLINE);
  143.         } catch(er) {}
  144.  
  145.         var storageManagerService = Cc["@mozilla.org/dom/storagemanager;1"].
  146.                                     getService(Ci.nsIDOMStorageManager);
  147.         storageManagerService.clearOfflineApps();
  148.       },
  149.  
  150.       get canClear()
  151.       {
  152.           return true;
  153.       }
  154.     },
  155.  
  156.     history: {
  157.       clear: function ()
  158.       {
  159.         var globalHistory = Components.classes["@mozilla.org/browser/global-history;2"]
  160.                                       .getService(Components.interfaces.nsIBrowserHistory);
  161.         if (this.range)
  162.           globalHistory.QueryInterface(Components.interfaces.nsIBrowserHistory_MOZILLA_1_9_1_ADDITIONS).removeVisitsByTimeframe(this.range[0], this.range[1]);
  163.         else
  164.           globalHistory.removeAllPages();
  165.         
  166.         try {
  167.           var os = Components.classes["@mozilla.org/observer-service;1"]
  168.                              .getService(Components.interfaces.nsIObserverService);
  169.           os.notifyObservers(null, "browser:purge-session-history", "");
  170.         }
  171.         catch (e) { }
  172.         
  173.         // Clear last URL of the Open Web Location dialog
  174.         var prefs = Components.classes["@mozilla.org/preferences-service;1"]
  175.                               .getService(Components.interfaces.nsIPrefBranch2);
  176.         try {
  177.           prefs.clearUserPref("general.open_location.last_url");
  178.         }
  179.         catch (e) { }
  180.       },
  181.       
  182.       get canClear()
  183.       {
  184.         // bug 347231: Always allow clearing history due to dependencies on
  185.         // the browser:purge-session-history notification. (like error console)
  186.         return true;
  187.       }
  188.     },
  189.     
  190.     formdata: {
  191.       clear: function ()
  192.       {
  193.         // Clear undo history of all searchBars
  194.         var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1']
  195.                                       .getService(Components.interfaces.nsIWindowMediator);
  196.         var windows = windowManager.getEnumerator("navigator:browser");
  197.         while (windows.hasMoreElements()) {
  198.           var searchBar = windows.getNext().document.getElementById("searchbar");
  199.           if (searchBar)
  200.             searchBar.textbox.reset();
  201.         }
  202.  
  203.         var formHistory = Components.classes["@mozilla.org/satchel/form-history;1"]
  204.                                     .getService(Components.interfaces.nsIFormHistory2);
  205.         if (this.range)
  206.           formHistory.removeEntriesByTimeframe(this.range[0], this.range[1]);
  207.         else
  208.           formHistory.removeAllEntries();
  209.       },
  210.  
  211.       get canClear()
  212.       {
  213.         var windowManager = Components.classes['@mozilla.org/appshell/window-mediator;1']
  214.                                       .getService(Components.interfaces.nsIWindowMediator);
  215.         var windows = windowManager.getEnumerator("navigator:browser");
  216.         while (windows.hasMoreElements()) {
  217.           var searchBar = windows.getNext().document.getElementById("searchbar");
  218.           if (searchBar) {
  219.             var transactionMgr = searchBar.textbox.editor.transactionManager;
  220.             if (searchBar.value ||
  221.                 transactionMgr.numberOfUndoItems ||
  222.                 transactionMgr.numberOfRedoItems)
  223.               return true;
  224.           }
  225.         }
  226.  
  227.         var formHistory = Components.classes["@mozilla.org/satchel/form-history;1"]
  228.                                     .getService(Components.interfaces.nsIFormHistory2);
  229.         return formHistory.hasEntries;
  230.       }
  231.     },
  232.     
  233.     downloads: {
  234.       clear: function ()
  235.       {
  236.         var dlMgr = Components.classes["@mozilla.org/download-manager;1"]
  237.                               .getService(Components.interfaces.nsIDownloadManager);
  238.  
  239.         var dlIDsToRemove = [];
  240.         if (this.range) {
  241.           // First, remove the completed/cancelled downloads
  242.           dlMgr.removeDownloadsByTimeframe(this.range[0], this.range[1]);
  243.           
  244.           // Queue up any active downloads that started in the time span as well
  245.           var dlsEnum = dlMgr.activeDownloads;
  246.           while(dlsEnum.hasMoreElements()) {
  247.             var dl = dlsEnum.next();
  248.             if(dl.startTime >= this.range[0])
  249.               dlIDsToRemove.push(dl.id);
  250.           }
  251.         }
  252.         else {
  253.           // Clear all completed/cancelled downloads
  254.           dlMgr.cleanUp();
  255.           
  256.           // Queue up all active ones as well
  257.           var dlsEnum = dlMgr.activeDownloads;
  258.           while(dlsEnum.hasMoreElements()) {
  259.             dlIDsToRemove.push(dlsEnum.next().id);
  260.           }
  261.         }
  262.         
  263.         // Remove any queued up active downloads
  264.         dlIDsToRemove.forEach(function(id) {
  265.           dlMgr.removeDownload(id);
  266.         });
  267.       },
  268.  
  269.       get canClear()
  270.       {
  271.         var dlMgr = Components.classes["@mozilla.org/download-manager;1"]
  272.                               .getService(Components.interfaces.nsIDownloadManager);
  273.         return dlMgr.canCleanUp;
  274.       }
  275.     },
  276.     
  277.     passwords: {
  278.       clear: function ()
  279.       {
  280.         var pwmgr = Components.classes["@mozilla.org/login-manager;1"]
  281.                               .getService(Components.interfaces.nsILoginManager);
  282.         // Passwords are timeless, and don't respect the timeSpan setting
  283.         pwmgr.removeAllLogins();
  284.       },
  285.       
  286.       get canClear()
  287.       {
  288.         var pwmgr = Components.classes["@mozilla.org/login-manager;1"]
  289.                               .getService(Components.interfaces.nsILoginManager);
  290.         var count = pwmgr.countLogins("", "", ""); // count all logins
  291.         return (count > 0);
  292.       }
  293.     },
  294.     
  295.     sessions: {
  296.       clear: function ()
  297.       {
  298.         // clear all auth tokens
  299.         var sdr = Components.classes["@mozilla.org/security/sdr;1"]
  300.                             .getService(Components.interfaces.nsISecretDecoderRing);
  301.         sdr.logoutAndTeardown();
  302.  
  303.         // clear plain HTTP auth sessions
  304.         var authMgr = Components.classes['@mozilla.org/network/http-auth-manager;1']
  305.                                 .getService(Components.interfaces.nsIHttpAuthManager);
  306.         authMgr.clearAll();
  307.       },
  308.       
  309.       get canClear()
  310.       {
  311.         return true;
  312.       }
  313.     },
  314.     
  315.     siteSettings: {
  316.       clear: function ()
  317.       {
  318.         var pm = Components.classes["@mozilla.org/permissionmanager;1"]
  319.                           .getService(Components.interfaces.nsIPermissionManager);
  320.         pm.removeAll();
  321.         
  322.         var cps = Components.classes["@mozilla.org/content-pref/service;1"]
  323.                            .getService(Components.interfaces.nsIContentPrefService);
  324.         cps.removeGroupedPrefs();
  325.       },
  326.       
  327.       get canClear()
  328.       {
  329.         return true;
  330.       }
  331.     }
  332.   }
  333. };
  334.  
  335.  
  336.  
  337. // "Static" members
  338. Sanitizer.prefDomain          = "privacy.sanitize.";
  339. Sanitizer.prefShutdown        = "sanitizeOnShutdown";
  340. Sanitizer.prefDidShutdown     = "didShutdownSanitize";
  341.  
  342. // Time span constants corresponding to values of the privacy.sanitize.timeSpan
  343. // pref.  Used to determine how much history to clear, for various items
  344. Sanitizer.TIMESPAN_EVERYTHING = 0;
  345. Sanitizer.TIMESPAN_HOUR       = 1;
  346. Sanitizer.TIMESPAN_2HOURS     = 2;
  347. Sanitizer.TIMESPAN_4HOURS     = 3;
  348. Sanitizer.TIMESPAN_TODAY      = 4;
  349.  
  350. // Return a 2 element array representing the start and end times,
  351. // in the uSec-since-epoch format that PRTime likes.  If we should
  352. // clear everything, return null.  Use ts if it is defined; otherwise
  353. // use the timeSpan pref.
  354. Sanitizer.getClearRange = function (ts) {
  355.   if (ts === undefined)
  356.     ts = Sanitizer.prefs.getIntPref("timeSpan");
  357.   if (ts === Sanitizer.TIMESPAN_EVERYTHING)
  358.     return null;
  359.   
  360.   // PRTime is microseconds while JS time is milliseconds
  361.   var endDate = Date.now() * 1000;
  362.   switch (ts) {
  363.     case Sanitizer.TIMESPAN_HOUR :
  364.       var startDate = endDate - 3600000000; // 1*60*60*1000000
  365.       break;
  366.     case Sanitizer.TIMESPAN_2HOURS :
  367.       startDate = endDate - 7200000000; // 2*60*60*1000000
  368.       break;
  369.     case Sanitizer.TIMESPAN_4HOURS :
  370.       startDate = endDate - 14400000000; // 4*60*60*1000000
  371.       break;
  372.     case Sanitizer.TIMESPAN_TODAY :
  373.       var d = new Date();  // Start with today
  374.       d.setHours(0);      // zero us back to midnight...
  375.       d.setMinutes(0);
  376.       d.setSeconds(0);
  377.       startDate = d.valueOf() * 1000; // convert to epoch usec
  378.       break;
  379.     default:
  380.       throw "Invalid time span for clear private data: " + ts;
  381.   }
  382.   return [startDate, endDate];
  383. };
  384.  
  385. Sanitizer._prefs = null;
  386. Sanitizer.__defineGetter__("prefs", function() 
  387. {
  388.   return Sanitizer._prefs ? Sanitizer._prefs
  389.     : Sanitizer._prefs = Components.classes["@mozilla.org/preferences-service;1"]
  390.                          .getService(Components.interfaces.nsIPrefService)
  391.                          .getBranch(Sanitizer.prefDomain);
  392. });
  393.  
  394. // Shows sanitization UI
  395. Sanitizer.showUI = function(aParentWindow) 
  396. {
  397.   var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  398.                      .getService(Components.interfaces.nsIWindowWatcher);
  399. //@line 441 "e:\builds\moz2_slave\win32_build\build\browser\base\content\sanitize.js"
  400.   ww.openWindow(aParentWindow,
  401. //@line 443 "e:\builds\moz2_slave\win32_build\build\browser\base\content\sanitize.js"
  402.                 "chrome://browser/content/sanitize.xul",
  403.                 "Sanitize",
  404.                 "chrome,titlebar,dialog,centerscreen,modal",
  405.                 null);
  406. };
  407.  
  408. /** 
  409.  * Deletes privacy sensitive data in a batch, optionally showing the 
  410.  * sanitize UI, according to user preferences
  411.  *
  412.  * @returns  null (displayed UI, which should handle errors)
  413.  */
  414. Sanitizer.sanitize = function(aParentWindow) 
  415. {
  416.   Sanitizer.showUI(aParentWindow);
  417.   return null;
  418. };
  419.  
  420. Sanitizer.onStartup = function() 
  421. {
  422.   // we check for unclean exit with pending sanitization
  423.   Sanitizer._checkAndSanitize();
  424. };
  425.  
  426. Sanitizer.onShutdown = function() 
  427. {
  428.   // we check if sanitization is needed and perform it
  429.   Sanitizer._checkAndSanitize();
  430. };
  431.  
  432. // this is called on startup and shutdown, to perform pending sanitizations
  433. Sanitizer._checkAndSanitize = function() 
  434. {
  435.   const prefs = Sanitizer.prefs;
  436.   if (prefs.getBoolPref(Sanitizer.prefShutdown) && 
  437.       !prefs.prefHasUserValue(Sanitizer.prefDidShutdown)) {
  438.     // this is a shutdown or a startup after an unclean exit
  439.     var s = new Sanitizer();
  440.     s.prefDomain = "privacy.clearOnShutdown.";
  441.     s.sanitize() || // sanitize() returns null on full success
  442.       prefs.setBoolPref(Sanitizer.prefDidShutdown, true);
  443.   }
  444. };
  445.  
  446.  
  447.